import {
  checkAllCart,
  deleteCart,
  findCart,
  getNewCartGoods,
  insertCart,
  mergeCart,
  updateCart,
} from '@/api/cart'
import Message from '@/components/library/Message'

// 购物车状态
export default {
  namespaced: true,
  state: () => {
    return {
      list: [],
    }
  },
  mutations: {
    // 设置购物车列表
    setCartList(state, list) {
      console.log(list)
      state.list = list
    },
    // 加入购物车
    insertCart(state, payload) {
      // payload 约定加入购物车字段必须和后端保持一致
      const sameIndex = state.list.findIndex(
        (goods) => goods.skuId === payload.skuId,
      )
      if (sameIndex > -1) {
        const count = state.list[sameIndex].count
        payload.count += count
        state.list.splice(sameIndex, 1)
      }
      state.list.unshift(payload)
    },
    // 修改购物车
    updateCart(state, goods) {
      let oldGoods = state.list.find((item) => item.skuId === goods.skuId)
      for (let k in goods) {
        if (goods[k] !== undefined && goods[k] !== null && goods[k] !== '') {
          oldGoods[k] = goods[k]
        }
      }
    },
    // 修改规格
    updateCartSku(state, { oldGoods, newGoods }) {
      // 找到对应 skuId 的商品信息，相同商品信息的话，拿到之前的数量然后累加到之前的

      // 根据修改后的 skuId 拿到之到相同商品的下标
      const oldIdx = state.list.findIndex(
        (item) => item.skuId === newGoods.skuId,
      )
      // 根据之前商品的 skuId 找到修改之前商品的位置
      const currIdx = state.list.findIndex(
        (item) => item.skuId === oldGoods.skuId,
      )
      if (oldIdx > -1) {
        // 找到了相同的就将修改后的 count 和之前的进行相加
        state.list[oldIdx].count += newGoods.count
        // 删除修改之前商品
        state.list.splice(currIdx, 1)
      } else {
        // 没有相同的直接更改规格数据就好了
        for (let k in newGoods) {
          if (
            newGoods[k] !== undefined &&
            newGoods[k] !== null &&
            newGoods[k] !== ''
          ) {
            oldGoods[k] = newGoods[k]
          }
        }
      }
    },
    // 删除购物车商品
    deleteCart(state, skuId) {
      const index = state.list.findIndex((item) => item.skuId === skuId)
      state.list.splice(index, 1)
    },
  },
  getters: {
    // 无效商品列表
    invalidList(state) {
      return state.list.filter((item) => !(item.stock > 0 && item.isEffective))
    },
    // 选中商品列表
    selectedList(state, getters) {
      return getters.validList.filter((item) => item.selected)
    },
    // 选中商品件数
    selectedTotal(state, getters) {
      return getters.selectedList.reduce((p, c) => p + c.count, 0)
    },
    // 选中商品总金额
    selectedAmount(state, getters) {
      return getters.selectedList
        .reduce((p, c) => p + c.nowPrice * c.count, 0)
        .toFixed(2)
    },
    // 是否全选
    isCheckAll(state, getters) {
      return (
        getters.validList.length === getters.selectedList.length &&
        getters.selectedList.length !== 0
      )
    },
    // 有效商品列表
    validList: (state) => {
      console.log(state)
      return state.list.filter((goods) => goods.stock > 0 && goods.isEffective)
    },
    // 有效商品总件数
    validTotal: (state, getters) =>
      // p 就是 0，c 每个对象
      getters.validList.reduce((p, c) => p + c.count, 0),
    // 有效商品总金额
    validAmount: (state, getters) =>
      getters.validList
        .reduce((p, c) => p + c.count * c.nowPrice, 0)
        .toFixed(2),
  },
  actions: {
    // 合并本地购物车
    async mergeLocalCart(store) {
      // 合并购物车
      const data = store.state.list.map(({ skuId, selected, count }) => ({
        skuId,
        selected,
        count,
      }))
      await mergeCart(data)
      // 清空本地
      // store.commit('setCartList', [])
      // 获取购物车列表
      const { result } = await findCart()
      store.commit('setCartList', result)
    },
    // 修改sku规格函数
    updateCartSku(store, { oldSkuId, newSku }) {
      return new Promise(async (resolve, reject) => {
        if (store.rootState.user.profile.token) {
          // 登录 TODO

          // 1. 拿到原先商品的数据
          const oldGoods = store.state.list.find(
            (item) => item.skuId === oldSkuId,
          )
          // 2. 将原来的进行删除
          await deleteCart([oldSkuId])
          // 3. 进行插入,传递新的 skuid 和原来商品的数量
          await insertCart({ skuId: newSku.skuId, count: oldGoods.count })
          // 4. 获取新数据
          const { result } = await findCart()
          // 5. 设置
          store.commit('setCartList', result)
        } else {
          // 本地
          // 1. 获取旧的商品信息
          const oldGoods = store.state.list.find(
            (item) => item.skuId === oldSkuId,
          )
          const { skuId, price: nowPrice, inventory: stock, attrsText } = newSku
          const newGoods = { ...oldGoods, skuId, nowPrice, stock, attrsText }
          store.commit('updateCartSku', { oldGoods, newGoods })
        }
      })
    },
    // updateCartSku(store, { oldSkuId, newSku }) {
    //   return new Promise((resolve, reject) => {
    //     if (store.rootState.user.profile.token) {
    //       // 登录 TODO
    //     } else {
    //       // 本地
    //       // 但你修改了sku的时候其实skuId需要更改，相当于把原来的信息移出，创建一条新的商品信息。
    //       // 1. 获取旧的商品信息
    //       const oldGoods = store.state.list.find(
    //         (item) => item.skuId === oldSkuId,
    //       )
    //       // 2. 删除旧的商品
    //       store.commit('deleteCart', oldSkuId)
    //       // 3. 合并一条新的商品信息
    //       const { skuId, price: nowPrice, inventory: stock, attrsText } = newSku
    //       const newGoods = { ...oldGoods, skuId, nowPrice, stock, attrsText }
    //       // 4. 去插入即可
    //       store.commit('insertCart', newGoods)
    //     }
    //   })
    // },

    // 做有效商品的全选&反选
    checkAllCart(store, selected) {
      return new Promise((resolve, reject) => {
        if (store.rootState.user.profile.token) {
          // 登录 TODO
          const ids = store.getters.validList.map((item) => item.skuId)
          checkAllCart({ selected, ids })
            .then(() => {
              return findCart()
            })
            .then((data) => {
              store.commit('setCartList', data.result)
              resolve()
            })
        } else {
          // 本地
          // 1. 获取有效的商品列表，遍历的去调用修改mutations即可
          store.getters.validList.forEach((item) => {
            store.commit('updateCart', {
              skuId: item.skuId,
              selected: selected,
            })
          })
          resolve()
        }
      })
    },
    // 修改购物车商品
    updateCart(store, goods) {
      // goods 中：必须有skuId，其他想修改的属性 selected  count
      return new Promise(async (resolve, reject) => {
        if (store.rootState.user.profile.token) {
          // 登录 TODO
          updateCart(goods)
            .then(() => {
              return findCart()
            })
            .then((data) => {
              store.commit('setCartList', data.result)
              resolve()
            })
        } else {
          // 本地
          store.commit('updateCart', goods)
          resolve()
        }
      })
    },
    // 加入购物车
    insertCart(context, payload) {
      return new Promise(async (resolve, reject) => {
        if (context.rootState.user.profile.token) {
          await insertCart({
            skuId: payload.skuId,
            count: payload.count,
          })
          Message({ msg: '加入购物车成功' })
          const { result } = await findCart()
          context.commit('setCartList', result)
        } else {
          context.commit('insertCart', payload)
          resolve()
        }
      })
    },
    // 获取商品列表
    async findCart(ctx) {
      if (ctx.rootState.user.profile.token) {
        // 获取购物车列表
        const { result } = await findCart()
        console.log('ddfafda', result)
        ctx.commit('setCartList', result)
      } else {
        const proArr = ctx.state.list.map((goods) => {
          return getNewCartGoods(goods.skuId)
        })
        try {
          const resList = await Promise.all(proArr)
          resList.forEach((item, idx) =>
            ctx.commit('updateCart', {
              skuId: ctx.state.list[idx].skuId,
              ...item.result,
            }),
          )
          Message({ msg: '更新商品成功！' })
        } catch (error) {
          Message({ type: 'error', msg: '更新商品失败！' })
        }
      }
    },
    async deleteCart(store, skuId) {
      if (store.rootState.user.profile.token) {
        // 登录 TODO
        deleteCart([skuId]).then(async () => {
          // 加入购物车成功后，直接获取并更新最新列表
          const { result } = await findCart()
          store.commit('setCartList', result)
        })
      } else {
        // 本地
        store.commit('deleteCart', skuId)
      }
      Message({ msg: '删除商品成功！' })
    }, // 批量删除选中商品
    batchDeleteCart(store, isInvalid) {
      return new Promise((resolve, reject) => {
        if (store.rootState.user.profile.token) {
          // 登录 TODO
          const ids = store.getters[
            isInvalid ? 'invalidList' : 'selectedList'
          ].map((item) => item.skuId)
          deleteCart(ids).then(async () => {
            // 加入购物车成功后，直接获取并更新最新列表
            const { result } = await findCart()
            store.commit('setCartList', result)
          })
          resolve()
        } else {
          // 本地
          // 1. 获取选中商品列表，进行遍历调用deleteCart mutataions函数
          store.getters[isInvalid ? 'invalidList' : 'selectedList'].forEach(
            (item) => {
              store.commit('deleteCart', item.skuId)
            },
          )
          resolve()
        }
      })
    },
  },
}
